An Investigation of the Cost of Agreement in Synchronization

The prevalence of multicore computers is leading to an increase in the amount of concurrent software. Unfortunately, parallelization does not necessarily improve performance. A concurrent program may run slower than the sequential equivalent. It may even scale negatively performance may get worse as more processors are added. It is important to understand the causes of this poor performance because the trend to multicore is likely to continue. This paper presents a suite of performance benchmarks which are used to examine the cost of synchronizing access to shared data. The components of the cost include the cost of blocking, the cost of atomic instructions, and the cost of sharing data. These costs can be described in terms of the need to agree on something. In the case of blocking, it is the need to agree on whose turn it is. In the case of atomic instructions, it is the need to agree on which CPU gets to execute the instruction next. In the case of sharing data, it is the need to agree on what the current value of a shared variable is. The benchmarks show that the agreement on the value of shared data is the main impediment to scalability. The benchmark results are used to predict the scalability properties of several common synchronization approaches. The approaches include locking, non-blocking synchronization, and relativistic programming. Each approach's need-to-agree is shown to be a useful predictor for the approach's performance and scalability.